#include "SingleAI.h"
#include "step.h"
#include <QTimer>

SingleAI::SingleAI()
{

}

void SingleAI::clickHandler(int id, int row, int col)
{
    if (isRedTurn)
        Board::clickHandler(id, row, col);
    if (!isRedTurn)
        QTimer::singleShot(100, this, SLOT(computerMove()));
}

void SingleAI::computerMove()
{
    Step *bestStep = NULL;
    int maxMinValues = INT_MIN; //人下完电脑的最低分中最高的

    clock_t startTime = clock();
    QVector<Step *> steps;
    getAllCanSteps(steps);
    //模拟走棋算出最高分
    while (steps.count()) {
        Step *step = steps.back();
        moveStone(step->fromId, step->rowTo, step->colTo);
        if (step->toId >= 0)
            stones[step->toId].isAlive = false;

        int tmpScore = calcScore();
//        int tmpScore = getMinScore(1, maxMinValues);
//        int tmpScore = negaMax(1);
//        int tmpScore = alphaBeta(maxDep, INT_MIN, INT_MAX);

        //还原
        if (step->toId >= 0)
            stones[step->toId].isAlive = true;
        moveStone(step->fromId, step->rowFrom, step->colFrom);

        if (tmpScore > maxMinValues) {
            maxMinValues = tmpScore;
            if (bestStep)
                delete bestStep;
            bestStep = step;
        } else
            delete step;
        steps.removeLast();
    }
    clock_t endTime = clock();
    qDebug() << "耗时：" << endTime - startTime;

    saveStep(bestStep->fromId, bestStep->rowTo, bestStep->colTo, bestStep->toId);
    if (bestStep->toId >= 0)
        stones[bestStep->toId].isAlive = false;
    moveStone(bestStep->fromId, bestStep->rowTo, bestStep->colTo);
    delete bestStep;
    checkWin();
    update();
}

//Step *bestStep = NULL;
//void SingleAI::computerMove()
//{
////    alphaBeta(maxDep, INT_MIN, INT_MAX);
//    negaMax(1);
//    moveStone(bestStep->fromId, bestStep->rowTo, bestStep->colTo);
//    if (bestStep->toId >= 0)
//        stones[bestStep->toId].isAlive = false;
//    delete bestStep;
//    checkWin();
//    update();
//}

void SingleAI::getAllCanSteps(QVector<Step *> &steps)
{
    int min = 0, max = 16;
    if (!isRedTurn) {
        min = 16;
        max = 32;
    }
    for (int i = min; i < max; i++)
        if (stones[i].isAlive)
            for (int row = 1; row < 11; row++)
                for (int col = 1; col < 10; col++) {
                    int targetId = getStoneId(row, col);
                    if (targetId >= 0 && stones[i].red == stones[targetId].red)
                        continue;
                    if (canMove(i, row, col)) {
                        Step *step = new Step;
                        step->rowFrom = stones[i].row;
                        step->colFrom = stones[i].col;
                        step->rowTo = row;
                        step->colTo = col;
                        step->fromId = i;
                        step->toId = targetId;
                        steps.append(step);
                    }
                }
}

////站在人方计算，人走完电脑的最低分
//int SingleAI::getMinScore(int lv, int curMaxMinScore)
//{
//    if (lv >= maxDep || !stones[4].isAlive || !stones[20].isAlive)
//        return calcScore();
//    int minScore = INT_MAX; //电脑下完电脑的最高分中最小的，最小化电脑的最大利益
//    QVector<Step*> steps;
//    getAllCanSteps(steps); //人的所有可走步
//    while (steps.count()){
//        Step *step = steps.back();
//        moveStone(step->fromId, step->rowTo, step->colTo);
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = false;
////        int tmpScore = calcScore();
//        int tmpScore = getMaxScore(lv+1, minScore);
//        //还原
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = true;
//        moveStone(step->fromId, step->rowFrom, step->colFrom);
//        //Alpha剪枝
//        if (tmpScore <= curMaxMinScore){
//            steps.clear();
//            return tmpScore;
//        }
//        if (tmpScore < minScore)
//            minScore = tmpScore;
//        steps.removeLast();
//    }
//    return minScore;
//}


////电脑下完电脑的最高分
//int SingleAI::getMaxScore(int lv, int curMinMaxScore)
//{
//    if (lv >= maxDep || !stones[4].isAlive || !stones[20].isAlive)
//        return calcScore();
//    int maxScore = INT_MIN; //人下完电脑的最低分中最大的，最大化电脑的最小利益
//    QVector<Step*> steps;
//    getAllCanSteps(steps); //电脑的所有可走步
//    while (steps.count()){
//        Step *step = steps.back();
//        moveStone(step->fromId, step->rowTo, step->colTo);
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = false;
//        int tmpScore = getMinScore(lv+1, maxScore);
//        //还原
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = true;
//        moveStone(step->fromId, step->rowFrom, step->colFrom);
//        //Beta剪枝
//        if (tmpScore >= curMinMaxScore) {
//            steps.clear();
//            return tmpScore;
//        }
//        if (tmpScore > maxScore)
//            maxScore = tmpScore;
//        steps.removeLast();
//    }
//    return maxScore;
//}

//int SingleAI::negaMax(int lv)
//{
//    if (lv >= maxDep || !stones[4].isAlive || !stones[20].isAlive)
//        return calcScore();
//    int value, bestValue = INT_MAX;
//    QVector<Step*> steps;
//    getAllCanSteps(steps);
//    while (steps.count()){
//        Step *step = steps.back();
//        //试走，产生新节点
//        moveStone(step->fromId, step->rowTo, step->colTo);
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = false;
//        value = -negaMax(lv+1); //递归搜索子节点
//        //还原
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = true;
//        moveStone(step->fromId, step->rowFrom, step->colFrom);
////        //剪枝
////        if (value <= curBestValue) {
////            steps.clear();
////            return value;
////        }
//        if (value < bestValue)
//            bestValue = value;
//        steps.removeLast();
//    }
//    return bestValue;
//}

//int SingleAI::negaMax(int lv)
//{
//    if (lv >= maxDep || !stones[4].isAlive || !stones[20].isAlive)
//        return calcScore();
//    int value, bestValue = INT_MIN;
//    QVector<Step*> steps;
//    getAllCanSteps(steps);
//    while (steps.count()){
//        Step *step = steps.back();
//        //试走，产生新节点
//        moveStone(step->fromId, step->rowTo, step->colTo);
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = false;
//        value = -negaMax(lv+1); //递归搜索子节点
//        //还原
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = true;
//        moveStone(step->fromId, step->rowFrom, step->colFrom);
//        if (value > bestValue) {
//            bestValue = value;
//            if (lv == 1) {
////                if (bestStep)
////                    delete bestStep;
//                bestStep = step;
//            }
//        }
//        steps.removeLast();
//    }
//    return bestValue;
//}

//int SingleAI::alphaBeta(int lv, int alpha, int beta)
//{
//    if (lv <= 0 || !stones[4].isAlive || !stones[20].isAlive)
//        return calcScore();
//    int value;
//    QVector<Step*> steps;
//    getAllCanSteps(steps);
//    while (steps.count()){
//        Step *step = steps.back();
//        //试走，产生新节点
//        moveStone(step->fromId, step->rowTo, step->colTo);
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = false;
//        value = -alphaBeta(lv-1, -beta, -alpha); //递归搜索子节点
//        //还原
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = true;
//        moveStone(step->fromId, step->rowFrom, step->colFrom);

//        if (value < beta)
//            beta = value;
//        if (alpha >= beta) {
//            steps.clear();
//            return alpha;
//        }
//        steps.removeLast();
//    }
//    return beta;
//}

//int SingleAI::alphaBeta(int lv, int alpha, int beta)
//{
//    if (lv <= 0 || !stones[4].isAlive || !stones[20].isAlive)
//        return calcScore();
//    int value;
//    QVector<Step*> steps;
//    getAllCanSteps(steps);
//    while (steps.count()){
//        Step *step = steps.back();
//        //试走，产生新节点
//        moveStone(step->fromId, step->rowTo, step->colTo);
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = false;
//        value = -alphaBeta(lv-1, -beta, -alpha); //递归搜索子节点
//        //还原
//        if (step->toId >= 0)
//            stones[step->toId].isAlive = true;
//        moveStone(step->fromId, step->rowFrom, step->colFrom);
////        //剪枝
////        if (alpha >= beta) {
////            steps.clear();
////            return alpha;
////        }
//        if (value > alpha) {
//            alpha = value;
//            if (lv == maxDep) {
////                if (bestStep)
////                    delete bestStep;
//                bestStep = step;
//            }
//        }
//        steps.removeLast();
//    }
//    return alpha;
//}

int SingleAI::calcScore()
{
    // enum TYPE{JIANG, CHE, MA, PAO, XIANG, SHI, BING};
    static int stoneScore[] = {999, 90, 40, 45, 17, 18, 15};
    int redSum = 0, blackSum = 0;
    for (int i = 0; i < 32; i++)
        if (stones[i].isAlive)
            if (i < 16)
                redSum += stoneScore[stones[i].type];
            else
                blackSum += stoneScore[stones[i].type];
    return blackSum - redSum;
//    return redSum - blackSum;
}
